home *** CD-ROM | disk | FTP | other *** search
/ Games of Daze / Infomagic - Games of Daze (Summer 1995) (Disc 1 of 2).iso / x2ftp / msdos / ai / tierra40 / tierra / soup_in.h < prev    next >
C/C++ Source or Header  |  1992-09-08  |  9KB  |  237 lines
  1. /* soup_in.h   9-9-92  Artificial Life simulator setup routines */
  2. /* Tierra Simulator V4.0: Copyright (c) 1991, 1992 Tom Ray & Virtual Life */
  3.  
  4. /*
  5.  * sccsid: @(#)soup_in.h    1.5    7/21/92
  6.  */
  7.  
  8. #include "license.h"
  9.  
  10. #ifndef SOUP_IN_H
  11. #define SOUP_IN_H
  12.  
  13. /* observational parameters: */
  14.  
  15. I32s BrkupSiz = 1024;  /* size of output file in K: break.1, break.2 ... */
  16. I32s CumGeneBnk = 0;    /* Use cumulative gene files, or overwrite */
  17. I32s debug = 0;           /* 0 = off, 1 = on, printf statements for debugging */
  18. I32s DiskOut = 1;      /* output data to disk (1 = on, 0 = off) */
  19. I32s GeneBnker = 1;    /* turn genebanker on and off */
  20. I8s GenebankPath[80] = "gb/";    /* path for genebanker output */
  21. I32s hangup = 0;    /* 0 = exit on error, 1 = hangup on error for debugging */
  22. I32s Log = 0;    /* 0 = no log file, 1 = write tierra.log file to disk */
  23. I32s MaxFreeBlocks = 600;/* initial # of structure for memory allocation */
  24. I8s OutPath[80] = "td/";    /* path for data output */
  25. I32s RamBankSiz = 30000;/* max num genotypes in ram, use with genebanker */
  26. I32s SaveFreq = 100;   /* frequency of saving core_out, soup_out and list */
  27. I32s  SavMinNum = 2;   /* minimum number of individuals to save genotype */
  28. float SavThrMem = .015;/* threshold memory occupancy to save genotype */
  29. float SavThrPop = .015;/* threshold population proportion to save genotype */
  30. I32s WatchExe = 0;     /* mark executed instructions in genome in genebank */
  31. I32s WatchMov = 0;     /* set mov bits in genome in genebank */
  32. I32s WatchTem = 0;     /* set template bits in genome in genebank */
  33.  
  34. /* environmental variables: */
  35.  
  36. I32s alive = 500;      /* how many millions of instruction will we run */
  37. float DistFreq = .3;    /* frequency of disturbance, factor of recovery time */
  38. float DistProp = .2;   /* proportion of population affected by distrubance */
  39. I32s DivSameSiz = 0;   /* produce offspring of same size, stop size change */
  40. I32s DivSameGen = 0;  /* produce offspring of same genotype, stop evolution */
  41. I32s DropDead = 5;     /* stop system if no reproduction in last x million */
  42. float GenPerBkgMut = 16.; /* mut rate control by generations ("cosmic ray") */
  43. float GenPerFlaw = 32.;/* flaw control by generations */
  44. float GenPerMovMut = 8.;/* mutation rate control by generations (copy mut) */
  45. I8s IMapFile[80] = "opcode.map"; /* map of instructions set into space */
  46. I32s MalMode = 2; /* 0 = first fit, 1 = better fit, 2 = random preference,
  47. 3 = near mother's address, 4 = near dx address, 5 = near top of stack address*/
  48. I32s MalReapTol = 1; /* 0 = reap by queue, 1 = reap oldest creat wthn MalTol */
  49. I32s MalTol = 5; /* multiple of avgsize to search for free block */
  50. float MateProb = .2;    /* probability of mating, this mal */
  51. I32s MateSearchL = 0;    /* Search limit to find a mate, like SearchLimit */
  52. I32s MateSizeEp = 1;    /* critters size +- val => allowed to mate with */
  53. float MateXoverProp = 1.0; /* prop. of gene to consider for Xover point */
  54. float MaxMalMult = 3;  /* multiple of cell size allowed for mal() */
  55. I32s MinCellSize = 8;  /* minimum size for cells */
  56. I32s MinTemplSize = 1; /* minimum size for templates */
  57. float MovPropThrDiv = .7;/* min proportion of daughter cell filled by mov */
  58. I32s MemModeFree = 0;  /* unix chmod for when mem is dealloced,  */
  59. I32s MemModeProt = 2;  /* unix chmod for when mem is Alloced, NOT fully impl!*/
  60. I32s new_soup = 1;     /* 1 = this a new soup, 0 = restarting an old run */
  61. I32s NumCells = 1;    /* # of creatures and gaps used to inoculate new soup */
  62. double PhotonPow = 1.5;/* power for photon match slice size */
  63. I32s PhotonWidth = 8;  /* amount by which photons slide to find best fit */
  64. I8s PhotonWord[80] = "chlorophill";    /* word used to define photon */
  65. float PutLimit = 20.;   /* distance for intercellular communication */
  66. float ReapRndProp = 0.0; /* rnd prop of top of reaper Q to reap from */
  67. float SearchLimit = 5.;   /* distance for template search */
  68. I32s seed = 0; /* seed for random number generator, 0 uses time to set seed */
  69. I32s SizDepSlice = 1;  /* set slice size by size of creature */
  70. double SlicePow = 1;  /* set power for slice size, use when SizDepSlice = 1 */
  71. I32s SliceSize = 25;   /* slice size when SizDepSlice = 0 */
  72. I32s SliceStyle = 2;   /* choose style of determining slice size */
  73. float SlicFixFrac = 0; /* fixed fraction of slice size */
  74. float SlicRanFrac = 2; /* random fraction of slice size */
  75. I32s SoupSize = 60000L;  /* size of soup in instructions */
  76.  
  77. /* an edited version of the id[INSTNUM] array must be created and placed in
  78.    the arginst.h file, for use by the assembler/disassembler of arg.c */
  79.  
  80. #if INST == 1
  81.  
  82. InstDef id[INSTNUM] = {
  83.     {0x00, "nop0", nop, pnop},
  84.     {0x01, "nop1", nop, pnop},
  85.     {0x02, "not0", not0, pnot0},
  86.     {0x03, "shl", shl, pshl},
  87.     {0x04, "zero", movdd, pzero},
  88.     {0x05, "ifz", ifz, pifz},
  89.     {0x06, "sub_ab", math, psub_ab},
  90.     {0x07, "sub_ac", math, psub_ac},
  91.     {0x08, "inc_a", math, pinc_a},
  92.     {0x09, "inc_b", math, pinc_b},
  93.     {0x0a, "dec_c", math, pdec_c},
  94.     {0x0b, "inc_c", math, pinc_c},
  95.     {0x0c, "pushax", push, ppushax},
  96.     {0x0d, "pushbx", push, ppushbx},
  97.     {0x0e, "pushcx", push, ppushcx},
  98.     {0x0f, "pushdx", push, ppushdx},
  99.     {0x10, "popax", pop, ppopax},
  100.     {0x11, "popbx", pop, ppopbx},
  101.     {0x12, "popcx", pop, ppopcx},
  102.     {0x13, "popdx", pop, ppopdx},
  103.     {0x14, "jmp", adr, ptjmp},
  104.     {0x15, "jmpb", adr, ptjmpb},
  105.     {0x16, "call", tcall, ptcall},
  106.     {0x17, "ret", pop, pret},
  107.     {0x18, "movcd", movdd, pmovdc},
  108.     {0x19, "movab", movdd, pmovba},
  109.     {0x1a, "movii", movii, pmovii},
  110.     {0x1b, "adr", adr, padr},
  111.     {0x1c, "adrb", adr, padrb},
  112.     {0x1d, "adrf", adr, padrf},
  113.     {0x1e, "mal", malchm, pmal},
  114.     {0x1f, "divide", divide, pdivide}
  115. };
  116.  
  117. #endif /* INST == 1 */
  118.  
  119. #if INST == 2
  120.  
  121. InstDef id[INSTNUM] = {
  122.     {0x00, "nop0", nop, pnop},
  123.     {0x01, "nop1", nop, pnop},
  124.     {0x02, "ax", regorder, pax},
  125.     {0x03, "bx", regorder, pbx},
  126.     {0x04, "cx", regorder, pcx},
  127.     {0x05, "dx", regorder, pdx},
  128.     {0x06, "movdd", movdd, pmovdd},
  129.     {0x07, "movdi", movdi, pmovdi},
  130.     {0x08, "movid", movid, pmovid},
  131.     {0x09, "movii", movii, pmovii},
  132.     {0x0a, "push", push, ppush},
  133.     {0x0b, "pop", pop, ppop},
  134.     {0x0c, "put", put, pput},
  135.     {0x0d, "get", get, pget},
  136.     {0x0e, "inc", math, pinc},
  137.     {0x0f, "dec", math, pdec},
  138.     {0x10, "add", math, padd},
  139.     {0x11, "sub", math, psub},
  140.     {0x12, "zero", movdd, pzero},
  141.     {0x13, "shl", shl, pshl},
  142.     {0x14, "not0", not0, pnot0},
  143.     {0x15, "not", not, pnot},
  144.     {0x16, "ifz", ifz, pifz},
  145.     {0x17, "iffl", ifz, piffl},
  146.     {0x18, "jmp", adr, ptjmp},
  147.     {0x19, "jmpb", adr, ptjmpb},
  148.     {0x1a, "call", tcall, ptcall},
  149.     {0x1b, "adr", adr, padr},
  150.     {0x1c, "adrb", adr, padrb},
  151.     {0x1d, "adrf", adr, padrf},
  152.     {0x1e, "mal", malchm, pmal},
  153.     {0x1f, "divide", divide, pdivide}
  154. };
  155.  
  156. #endif /* INST == 2 */
  157.  
  158. #if INST == 3
  159.  
  160. InstDef id[INSTNUM] = {
  161.     {0x00, "nop0", nop, pnop},
  162.     {0x01, "nop1", nop, pnop},
  163.     {0x02, "rollu", rollu, pnop},
  164.     {0x03, "rolld", rolld, pnop},
  165.     {0x04, "enter", enter, pnop},
  166.     {0x05, "exch", exch, pnop},
  167.     {0x06, "movdi", movdi, pmovdi},
  168.     {0x07, "movid", movid, pmovid},
  169.     {0x08, "movii", movii, pmovii},
  170.     {0x09, "push", push, ppush},
  171.     {0x0a, "pop", pop3, ppop},
  172.     {0x0b, "put", put, pput},
  173.     {0x0c, "get", get, pget},
  174.     {0x0d, "inc", math, pinc},
  175.     {0x0e, "dec", math, pdec},
  176.     {0x0f, "add", math3, padd},
  177.     {0x10, "sub", math3, psub},
  178.     {0x11, "zero", movdd3, pzero},
  179.     {0x12, "shl", shl, pshl},
  180.     {0x13, "not0", not0, pnot0},
  181.     {0x14, "not", not, pnot},
  182.     {0x15, "rand", movdd3, prand},
  183.     {0x16, "ifz", ifz, pifz},
  184.     {0x17, "iffl", ifz, piffl},
  185.     {0x18, "jmp", adr, ptjmp},
  186.     {0x19, "jmpb", adr, ptjmpb},
  187.     {0x1a, "call", tcall, ptcall},
  188.     {0x1b, "adr", adr3, padr},
  189.     {0x1c, "adrb", adr3, padrb},
  190.     {0x1d, "adrf", adr3, padrf},
  191.     {0x1e, "mal", malchm3, pmal},
  192.     {0x1f, "divide", divide, pdivide}
  193. };
  194.  
  195. #endif /* INST == 3 */
  196.  
  197. #if INST == 4
  198.  
  199. InstDef id[INSTNUM] = {
  200.     {0x00, "nop0", nop, pnop},
  201.     {0x01, "nop1", nop, pnop},
  202.     {0x02, "movdi", movdi, pmovdi},
  203.     {0x03, "movid", movid, pmovid},
  204.     {0x04, "movii", movii, pmovii},
  205.     {0x05, "pushax", push, ppushax},
  206.     {0x06, "pushbx", push, ppushbx},
  207.     {0x07, "pushcx", push, ppushcx},
  208.     {0x08, "pushdx", push, ppushdx},
  209.     {0x09, "popax", pop, ppopax},
  210.     {0x0a, "popbx", pop, ppopbx},
  211.     {0x0b, "popcx", pop, ppopcx},
  212.     {0x0c, "popdx", pop, ppopdx},
  213.     {0x0d, "put", put, pput},
  214.     {0x0e, "get", get, pget},
  215.     {0x0f, "inc", math, pinc},
  216.     {0x10, "dec", math, pdec},
  217.     {0x11, "add", math, padd},
  218.     {0x12, "sub", math, psub},
  219.     {0x13, "zero", movdd, pzero},
  220.     {0x14, "shl", shl, pshl},
  221.     {0x15, "not0", not0, pnot0},
  222.     {0x16, "ifz", ifz, pifz},
  223.     {0x17, "iffl", ifz, piffl},
  224.     {0x18, "jmp", adr, ptjmp},
  225.     {0x19, "jmpb", adr, ptjmpb},
  226.     {0x1a, "call", tcall, ptcall},
  227.     {0x1b, "adr", adr, padr},
  228.     {0x1c, "adrb", adr, padrb},
  229.     {0x1d, "adrf", adr, padrf},
  230.     {0x1e, "mal", malchm, pmal},
  231.     {0x1f, "divide", divide, pdivide}
  232. };
  233.  
  234. #endif /* INST == 4 */
  235.  
  236. #endif /* SOUP_IN_H */
  237.